home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / cc_rcc.c < prev    next >
C/C++ Source or Header  |  1994-04-25  |  27KB  |  977 lines
  1. /*****************************************************************************
  2.   FILE           : cc_rcc.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Common functions of CC and RCC
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Michael Schmalzl
  10.   DATE           : 5.2.93
  11.  
  12.   CHANGED BY     : Michael Vogt, Guenter Mamier
  13.   IDENTIFICATION : @(#)cc_rcc.c    1.12 4/12/94
  14.   SCCS VERSION   : 1.12
  15.   LAST CHANGE    : 4/12/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20.  
  21. #include <stdio.h>
  22. #include <math.h>
  23. #include <time.h>  
  24. #include <memory.h>
  25. #include <malloc.h>
  26. #include <values.h>
  27.  
  28. #include "kr_typ.h"    
  29. #include "kr_const.h"     
  30. #include "kr_def.h"     
  31. #include "random.h"
  32. #include "kr_mac.h"
  33. #include "kernel.h"
  34. #include "kr_ui.h"
  35. #include "kr_newpattern.h"
  36. #include "cc_mac.h"    
  37. #include "cc_type.h"
  38. #include "cc_rcc.ph"   
  39.  
  40. /*****************************************************************************
  41.   FUNCTION : cc_freeStorage
  42.  
  43.   PURPOSE  : Frees all the storage allocated by CC or RCC.
  44.   NOTES    :
  45.  
  46.   UPDATE   : 5.2.93
  47. ******************************************************************************/
  48.  
  49.  
  50. krui_err cc_freeStorage(int dummy1, int dummy2, int flag)
  51. {
  52.  int p,s;
  53.  struct Unit *unitPtr;
  54.  struct Link *linkPtr;
  55.  int start, end;
  56.  
  57.  start = old.StartPattern;
  58.  end = old.EndPattern;
  59.  
  60.  cc_storageFree = 1;
  61.  
  62.  if(flag==1){
  63.    (void) cc_deleteAllSpecialAndAllHiddenUnits();
  64.    cc_end = 0;
  65.  
  66.    FOR_ALL_UNITS(unitPtr){
  67.      if(UNIT_IN_USE(unitPtr) && IS_OUTPUT_UNIT(unitPtr)){
  68.        unitPtr->value_a =  unitPtr->value_b = unitPtr->value_c = 0;
  69.        FOR_ALL_LINKS(unitPtr,linkPtr){
  70.          linkPtr->value_a =  linkPtr->value_b = linkPtr->value_c = 0;
  71.        }
  72.      }
  73.    }
  74.  }
  75.  
  76.  IF_PTR_IS_NOT_NULL(OutputUnitError) {
  77.    FOR_ALL_PATTERNS(start,end,p) 
  78.      IF_PTR_IS_NOT_NULL(OutputUnitError[p])
  79.        free(OutputUnitError[p]);
  80.    free(OutputUnitError);
  81.    OutputUnitError = NULL;
  82.  }
  83.  
  84.  IF_PTR_IS_NOT_NULL(SpecialUnitAct) {
  85.    FOR_ALL_PATTERNS(start,end,p) 
  86.      IF_PTR_IS_NOT_NULL(SpecialUnitAct[p])
  87.        free(SpecialUnitAct[p]);
  88.    free(SpecialUnitAct);
  89.    SpecialUnitAct = NULL;
  90.  }
  91.  
  92.  IF_PTR_IS_NOT_NULL(CorBetweenSpecialActAndOutError) {
  93.      for(s=0;s<OldNoOfSpecialUnitStorage;s++){
  94.        IF_PTR_IS_NOT_NULL(CorBetweenSpecialActAndOutError[s])
  95.          free(CorBetweenSpecialActAndOutError[s]); 
  96.      }
  97.    free(CorBetweenSpecialActAndOutError);  
  98.    CorBetweenSpecialActAndOutError = NULL;
  99.  } 
  100.  
  101.  IF_PTR_IS_NOT_NULL(OutputUnitSumError) {
  102.    free(OutputUnitSumError);
  103.    OutputUnitSumError = NULL;
  104.  }
  105.  
  106.  IF_PTR_IS_NOT_NULL(SpecialUnitSumAct) {
  107.    free(SpecialUnitSumAct);
  108.    SpecialUnitSumAct = NULL;
  109.  }
  110.  
  111.  return(KRERR_NO_ERROR);
  112. }
  113.  
  114. /*****************************************************************************
  115.   FUNCTION : cc_allocateStorage
  116.  
  117.   PURPOSE  : Allocates all the storage needed by CC and RCC
  118.   NOTES    :
  119.  
  120.   UPDATE   : 5.2.93
  121. ******************************************************************************/
  122.  
  123. krui_err cc_allocateStorage(int StartPattern, int  EndPattern, int NoOfSpecialUnits)
  124. {
  125.  int s,p;
  126.  struct Unit *dummyPtr;
  127.  int start, end;
  128.  
  129.  OldNoOfSpecialUnitStorage = NoOfSpecialUnits;
  130.  cc_storageFree = 0;
  131.  
  132.  KernelErrorCode = kr_initSubPatternOrder(StartPattern,EndPattern);
  133.  ERROR_CHECK;
  134.  start = kr_AbsPosOfFirstSubPat(StartPattern);
  135.  end   = kr_AbsPosOfFirstSubPat(EndPattern);
  136.  end  += kr_NoOfSubPatPairs(EndPattern) - 1;
  137.  
  138.  OutputUnitSumError = (float *) calloc(NoOfOutputUnits,sizeof(float));
  139.  if(OutputUnitSumError == NULL) {
  140.    CC_ERROR(KRERR_CC_ERROR3);
  141.  }
  142.  SpecialUnitSumAct = (float *) calloc(NoOfSpecialUnits,sizeof(float));
  143.  if(SpecialUnitSumAct == NULL) {
  144.    CC_ERROR(KRERR_CC_ERROR3);
  145.  }
  146.  OutputUnitError = (float **)calloc(end-start+1,sizeof(float *));
  147.  if(OutputUnitError == NULL) {
  148.    CC_ERROR(KRERR_CC_ERROR3);
  149.  }
  150.  SpecialUnitAct = (float **)calloc(end-start+1,sizeof(float *));
  151.  if(SpecialUnitAct == NULL) {
  152.    CC_ERROR(KRERR_CC_ERROR3);
  153.  }
  154.  CorBetweenSpecialActAndOutError =  (float **)calloc(NoOfSpecialUnits,sizeof(float *));
  155.  if(CorBetweenSpecialActAndOutError == NULL) {
  156.    CC_ERROR(KRERR_CC_ERROR3);
  157.  }
  158.  
  159.  
  160.  FOR_ALL_PATTERNS(start,end,p) {
  161.    OutputUnitError[p] = (float *)calloc(NoOfOutputUnits,sizeof(float));
  162.    if(OutputUnitError[p] == NULL) {
  163.      CC_ERROR(KRERR_CC_ERROR3);
  164.    }
  165.    SpecialUnitAct[p] = (float *)calloc(NoOfSpecialUnits,sizeof(float));
  166.    if(SpecialUnitAct[p] == NULL) {
  167.      CC_ERROR(KRERR_CC_ERROR3);
  168.    }
  169.  }
  170.  
  171.  FOR_ALL_SPECIAL_UNITS(dummyPtr,s) {
  172.    CorBetweenSpecialActAndOutError[s] = (float *)calloc(NoOfOutputUnits,sizeof(float));   
  173.    if(CorBetweenSpecialActAndOutError[s] == NULL) {
  174.      CC_ERROR(KRERR_CC_ERROR3);
  175.    }
  176.  } 
  177.  
  178.  old.EndPattern       = end;
  179.  old.StartPattern     = start;
  180.  
  181.  return(KRERR_NO_ERROR);
  182. }
  183.  
  184. /*****************************************************************************
  185.   FUNCTION : cc_deleteAllSpecialAndAllHiddenUnits
  186.  
  187.   PURPOSE  : Deletes all special units and all hidden units.
  188.   NOTES    :
  189.  
  190.   UPDATE   : 5.2.93
  191. ******************************************************************************/
  192.  
  193. krui_err cc_deleteAllSpecialAndAllHiddenUnits(void)
  194. {
  195.  struct Unit *UnitPtr;
  196.  
  197.  if(NoOfUnits != 0) {
  198.    FOR_ALL_UNITS(UnitPtr){
  199.      if((IS_HIDDEN_UNIT(UnitPtr) || IS_SPECIAL_UNIT(UnitPtr)) && UNIT_IN_USE(UnitPtr)) {
  200.        KernelErrorCode = kr_removeUnit(UnitPtr); 
  201.        ERROR_CHECK;
  202.      }
  203.    }
  204.    kr_forceUnitGC();
  205.    NoOfHiddenUnits = 0;
  206.    NetModified = 1;
  207.  }
  208.  return(KRERR_NO_ERROR);
  209. } 
  210.  
  211. /*****************************************************************************
  212.   FUNCTION : rcc_manageResetArray
  213.  
  214.   PURPOSE  : Allocates the storage of the reset array in needed.
  215.   NOTES    :
  216.  
  217.   UPDATE   : 5.2.93
  218. ******************************************************************************/
  219.  
  220. void rcc_manageResetArray(int startPattern, int endPattern, int flag) 
  221. {
  222.  int p;
  223.  int start, end;
  224.  int pat, sub;
  225.  int size;
  226.  Patterns pat_ptr;
  227.  
  228.  if(reset!=NULL){
  229.    free(reset);
  230.  }
  231.  reset = NULL;
  232.  
  233.  if(flag){
  234.    reset = (int *) calloc(kr_TotalNoOfSubPatPairs(),sizeof(int));
  235.    reset[0] = 1;
  236.    KernelErrorCode = kr_initSubPatternOrder(startPattern,endPattern);
  237.    if (KernelErrorCode != KRERR_NO_ERROR)
  238.        return;
  239.    start = kr_AbsPosOfFirstSubPat(startPattern+1);
  240.    end   = kr_AbsPosOfFirstSubPat(endPattern-1);
  241.    end  += kr_NoOfSubPatPairs(endPattern-1) - 1;
  242.    for(p=start; p<=end;p++){
  243.        kr_getSubPatternByNo(&pat,&sub,p);
  244.        pat_ptr = kr_getSubPatData(pat,sub,OUTPUT,&size);
  245.        if( *(pat_ptr + size - 1) > 0.0 ) {
  246.        reset[p+1] = 1; 
  247.      }
  248.    }
  249.  }
  250. }
  251.  
  252. /*****************************************************************************
  253.   FUNCTION : rcc_manageLinkArray
  254.  
  255.   PURPOSE  : Allocates the storage of the link array if needed.
  256.   NOTES    :
  257.  
  258.   UPDATE   : 5.2.93
  259. ******************************************************************************/
  260.  
  261. void rcc_manageLinkArray(int newNoOfSpecialUnits, int flag)
  262. {
  263.  static int oldNoOfSpecialUnits=0;
  264.  int i,noOfHiddenUnits=0;
  265.  struct Unit *unit_ptr;
  266.  
  267.  for(i=0;i<oldNoOfSpecialUnits;i++){
  268.    if(linkArray[i]!=NULL){
  269.      free(linkArray[i]);
  270.    }
  271.  }
  272.  if(linkArray!=NULL){
  273.    free(linkArray);
  274.  }
  275.  
  276.  oldNoOfSpecialUnits = 0;
  277.  
  278.  if(flag){
  279.    FOR_ALL_UNITS(unit_ptr){
  280.      if(IS_HIDDEN_UNIT(unit_ptr)){
  281.        noOfHiddenUnits++;
  282.      }
  283.    }
  284.    linkArray = (float **) calloc(newNoOfSpecialUnits,sizeof(float *));
  285.  
  286.    for(i=0;i<newNoOfSpecialUnits;i++){
  287.      linkArray[i] = (float *) calloc(newNoOfSpecialUnits+noOfHiddenUnits+2,sizeof(float));
  288.    }
  289.    
  290.    oldNoOfSpecialUnits = newNoOfSpecialUnits;
  291.  }
  292. }
  293.  
  294.  
  295. /*****************************************************************************
  296.   FUNCTION : cc_initErrorArrays
  297.  
  298.   PURPOSE  : 
  299.   NOTES    :
  300.  
  301.   UPDATE   : 5.2.93
  302. ******************************************************************************/
  303.  
  304. void cc_initErrorArrays(void)
  305. {
  306.  int o;
  307.  struct Unit *outputUnitPtr;
  308.  
  309.   FOR_ALL_OUTPUT_UNITS(outputUnitPtr,o) {
  310.     OutputUnitSumError[o] = 0.0;
  311.   }
  312. }
  313.  
  314. /*****************************************************************************
  315.   FUNCTION : cc_initActivationArrays
  316.  
  317.   PURPOSE  : 
  318.   NOTES    :
  319.  
  320.   UPDATE   : 5.2.93
  321. ******************************************************************************/
  322.  
  323. void cc_initActivationArrays(void)
  324. {
  325.  int s,o;
  326.  struct Unit *outputUnitPtr,*specialUnitPtr;
  327.  
  328.   FOR_ALL_SPECIAL_UNITS(specialUnitPtr,s) {
  329.     SpecialUnitSumAct[s] = 0.0;
  330.   }
  331.  
  332.  FOR_ALL_SPECIAL_UNITS(specialUnitPtr,s) {
  333.    FOR_ALL_OUTPUT_UNITS(outputUnitPtr,o) {
  334.     CorBetweenSpecialActAndOutError[s][o] = 0.0;
  335.   }
  336.  } 
  337. }
  338.  
  339.  
  340. /*****************************************************************************
  341.   FUNCTION : cc_generateRandomNo
  342.  
  343.   PURPOSE  : Generates a random number in the interval [-maxValue,+maxValue]
  344.   NOTES    :
  345.  
  346.   UPDATE   : 5.2.93
  347. ******************************************************************************/
  348.  
  349. FlintType cc_generateRandomNo(float maxValue)
  350. {
  351.  return (FlintType)(drand48()*2.0*maxValue-maxValue);  
  352. }
  353.  
  354. /*****************************************************************************
  355.   FUNCTION : cc_compareActFunctions
  356.  
  357.   PURPOSE  : Tests wether the selected activation functions are consistent. 
  358.   NOTES    :
  359.  
  360.   UPDATE   : 5.2.93
  361. ******************************************************************************/
  362.  
  363.  
  364. void cc_compareActFunctions(int actFunc, int flag)
  365. {
  366.  int found_h=0,found_o=0;
  367.  struct Unit *unit_ptr,*hiddenUnitPtr,*outputUnitPtr;
  368.  char name_o[30],name_h[30];
  369.  
  370.  if((actFunc != RANDOM) && cc_printOnOff){
  371.    FOR_ALL_UNITS(unit_ptr){
  372.      if(IS_HIDDEN_UNIT(unit_ptr) && found_h != 1){
  373.        hiddenUnitPtr = unit_ptr;
  374.        strcpy(name_h,krui_getUnitActFuncName(GET_UNIT_NO(outputUnitPtr)));
  375.        found_h = 1;
  376.      }
  377.      if(IS_OUTPUT_UNIT(unit_ptr) && found_o != 1){
  378.        outputUnitPtr = unit_ptr;
  379.        strcpy(name_o,krui_getUnitActFuncName(GET_UNIT_NO(outputUnitPtr)));
  380.        found_o = 1;
  381.      }
  382.      if(found_h && found_o){
  383.        break;
  384.      }
  385.    }
  386.    if(flag == CC){
  387.      if(found_o && strcmp(cc_actFuncArray[actFunc],name_o)){
  388.        printf("!!! Warning: Output units and special units have different act. functions !!!\n");
  389.      }
  390.    }
  391.    else {
  392.      if(found_o && strcmp(rcc_actFuncArray[actFunc],name_o)){
  393.        printf("!!! Warning: Output units and special units have different act. functions !!! \n");
  394.      }
  395.    }
  396.    if(flag == CC){
  397.      if(found_h && strcmp(cc_actFuncArray[actFunc],name_h)){
  398.        printf("!!! Warning: Hidden units and special units have different act. functions !!!\n");
  399.      }
  400.    }
  401.    else {
  402.      if(found_h && strcmp(rcc_actFuncArray[actFunc],name_h)){
  403.        printf("!!! Warning: Hidden units and special units have different act. functions !!! \n");
  404.      }
  405.    }
  406.  
  407.    if(found_h && (outputUnitPtr->act_func != hiddenUnitPtr->act_func)){
  408.      printf("!!! Warning:  Output units and hidden units have different act. functions !!! \n");
  409.    }
  410.  }
  411. }
  412.  
  413. /*****************************************************************************
  414.   FUNCTION : cc_changeActFuncOfSpecialUnit
  415.  
  416.   PURPOSE  : Changes the activation function of the special units.
  417.   NOTES    :
  418.  
  419.   UPDATE   : 5.2.93
  420. ******************************************************************************/
  421.  
  422. krui_err cc_changeActFuncOfSpecialUnits(int type, int LearnFunc)
  423. {
  424.  int s,selector;
  425.  struct Unit *specialUnitPtr;
  426.  
  427.  FOR_ALL_SPECIAL_UNITS(specialUnitPtr,s) {
  428.    if(type==RANDOM){
  429.      selector = s % (NO_OF_ACT_FUNCS - 1);
  430.    }
  431.    else {
  432.      selector = type;
  433.    }
  434.    if(LearnFunc == CC){
  435.      KernelErrorCode = krui_setUnitActFunc(GET_UNIT_NO(specialUnitPtr),cc_actFuncArray[selector]);
  436.      ERROR_CHECK;  
  437.    }
  438.    else {
  439.      KernelErrorCode = krui_setUnitActFunc(GET_UNIT_NO(specialUnitPtr),cc_actFuncArray[selector]);
  440.      ERROR_CHECK;  
  441.    }
  442.  }
  443.  return(KRERR_NO_ERROR);
  444. }
  445.  
  446. /*****************************************************************************
  447.   FUNCTION : cc_calculateNetParameters
  448.  
  449.   PURPOSE  : Calculates the position of the current input, hidden and output
  450.              layer.
  451.   NOTES    :
  452.  
  453.   UPDATE   : 5.2.93
  454. ******************************************************************************/
  455.  
  456. krui_err cc_calculateNetParameters(int *maxYPosOfHiddenUnit, int *xPosOfLastInsertedHiddenUnit,
  457.                                    int *yPosOfLastInsertedHiddenUnit, int *outXMax)
  458. {         
  459.  struct Unit *unitPtr;
  460.  int x,y;
  461.  int inputXMin=0,inputXMax=0,hiddenXMin=0,hiddenXMax=0,outputXMin=0,outputXMax=0;
  462.  int inputYMin=0,inputYMax=0,hiddenYMin=0,hiddenYMax=0,outputYMin=0,outputYMax=0;
  463.  int xInputOffset=0,xHiddenOffset=0,xOutputOffset=0;
  464.  int yInputOffset=0,yHiddenOffset=0,yOutputOffset=0;
  465.  
  466.  NoOfInputUnits  = 0;
  467.  NoOfHiddenUnits = 0;
  468.  NoOfOutputUnits = 0;
  469.   
  470.  FOR_ALL_UNITS(unitPtr){
  471.    if(IS_INPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  472.      x = GET_UNIT_XPOS(unitPtr);
  473.      y = GET_UNIT_YPOS(unitPtr);
  474.      NoOfInputUnits++;
  475.      if((y >= inputYMax) || (inputYMax==0)){
  476.        inputYMax = y;
  477.      }
  478.      if((y <= inputYMin) || (inputYMin==0)){
  479.        inputYMin = y;
  480.      }
  481.      if((x >= inputXMax) || (inputXMax==0)){
  482.        inputXMax = x;
  483.      }
  484.      if((x <= inputXMin) || (inputXMin==0)){
  485.        inputXMin = x;
  486.      }
  487.    }
  488.    else if(IS_HIDDEN_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  489.      x = GET_UNIT_XPOS(unitPtr);
  490.      y = GET_UNIT_YPOS(unitPtr);
  491.      NoOfHiddenUnits++;
  492.      if((y >= hiddenYMax) || (hiddenYMax==0)){
  493.        hiddenYMax = y;
  494.      }
  495.      if((y <= hiddenYMin) || (hiddenYMin==0)){
  496.        hiddenYMin = y;
  497.      }
  498.      if((x >= hiddenXMax) || (hiddenXMax==0)){
  499.        hiddenXMax = x;
  500.      }
  501.      if((x <= hiddenXMin) || (hiddenXMin==0)){
  502.        hiddenXMin = x;
  503.      }
  504.    }
  505.    else if(IS_OUTPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  506.      x = GET_UNIT_XPOS(unitPtr);
  507.      y = GET_UNIT_YPOS(unitPtr);
  508.      NoOfOutputUnits++;
  509.      if((y >= outputYMax) || (outputYMax==0)){
  510.        outputYMax = y;
  511.      }
  512.      if((y <= outputYMin) || (outputYMin==0)){
  513.        outputYMin = y;
  514.      }
  515.      if((x >= outputXMax) || (outputXMax==0)){
  516.        outputXMax = x;
  517.      }
  518.      if((x <= outputXMin) || (outputXMin==0)){
  519.        outputXMin = x;
  520.      }
  521.    }
  522.  }
  523.  
  524.  if(NoOfHiddenUnits==0){
  525.    hiddenXMax = hiddenXMin = X_MIN_POS + (inputXMax-inputXMin) + 3;
  526.    hiddenYMax = hiddenYMin = Y_MIN_POS;
  527.    *outXMax = X_MIN_POS + (inputXMax-inputXMin) + (hiddenXMax-hiddenXMin) + 6;
  528.    *xPosOfLastInsertedHiddenUnit = X_MIN_POS + (inputXMax - inputXMin) + 3;
  529.  }
  530.  else {
  531.    *xPosOfLastInsertedHiddenUnit = X_MIN_POS + (inputXMax - inputXMin) + (hiddenXMax - hiddenXMin) + 3;
  532.    *outXMax = X_MIN_POS + (inputXMax-inputXMin) + (hiddenXMax-hiddenXMin) + (outputXMax-outputXMin) + 6;
  533.  }
  534.  *yPosOfLastInsertedHiddenUnit = Y_MIN_POS-1;
  535.  if(NoOfHiddenUnits==0) {
  536.    *maxYPosOfHiddenUnit = Y_MIN_POS + HIDDEN_LAYER_HEIGHT - 1;
  537.  }
  538.  else {
  539.    if(hiddenYMax - hiddenYMin + 1 >= MIN_HIDDEN_LAYER_HEIGHT) {
  540.      *maxYPosOfHiddenUnit = Y_MIN_POS + (hiddenYMax-hiddenYMin);
  541.    }
  542.    else {
  543.      *maxYPosOfHiddenUnit = Y_MIN_POS + HIDDEN_LAYER_HEIGHT - 1;
  544.    }
  545.  }
  546.  
  547.  xInputOffset = X_MIN_POS - inputXMin;
  548.  yInputOffset = Y_MIN_POS - inputYMin;
  549.  
  550.  xHiddenOffset = X_MIN_POS + (inputXMax-inputXMin) - hiddenXMin + 3;
  551.  yHiddenOffset = Y_MIN_POS - hiddenYMin;
  552.  
  553.  xOutputOffset = X_MIN_POS + (inputXMax-inputXMin) + (hiddenXMax-hiddenXMin) - outputXMin + 6;
  554.  yOutputOffset = Y_MIN_POS - outputYMin;   
  555.  
  556.  FOR_ALL_UNITS(unitPtr){
  557.    if(IS_INPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr) ) {
  558.      SET_UNIT_XPOS(unitPtr,GET_UNIT_XPOS(unitPtr)+xInputOffset);
  559.      SET_UNIT_YPOS(unitPtr,GET_UNIT_YPOS(unitPtr)+yInputOffset);
  560.    }
  561.    if(IS_HIDDEN_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)) {
  562.      SET_UNIT_XPOS(unitPtr,GET_UNIT_XPOS(unitPtr)+xHiddenOffset);
  563.      SET_UNIT_YPOS(unitPtr,GET_UNIT_YPOS(unitPtr)+yHiddenOffset);
  564.    }
  565.    if(IS_OUTPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr) ) {
  566.      SET_UNIT_XPOS(unitPtr,GET_UNIT_XPOS(unitPtr)+xOutputOffset);
  567.      SET_UNIT_YPOS(unitPtr,GET_UNIT_YPOS(unitPtr)+yOutputOffset);
  568.    }
  569.  }
  570.  
  571.  if(NoOfHiddenUnits!=0) {
  572.    FOR_ALL_UNITS(unitPtr){
  573.      if(IS_HIDDEN_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)) {
  574.        x = GET_UNIT_XPOS(unitPtr);
  575.        y = GET_UNIT_YPOS(unitPtr);
  576.        if(x == *xPosOfLastInsertedHiddenUnit){
  577.          if(y >= *yPosOfLastInsertedHiddenUnit){
  578.            *yPosOfLastInsertedHiddenUnit = y;
  579.          }
  580.        }
  581.      }
  582.    }
  583.  }
  584.  return(KRERR_NO_ERROR);
  585. }
  586.  
  587.   
  588. /*****************************************************************************
  589.   FUNCTION : cc_initOutputUnits
  590.  
  591.   PURPOSE  : Initializes the links of the output units.
  592.   NOTES    :
  593.  
  594.   UPDATE   : 5.2.93
  595. ******************************************************************************/
  596.  
  597. void cc_initOutputUnits(void)
  598. {
  599.  struct Unit *outputUnitPtr;
  600.  struct Link *linkPtr;
  601.  int o;
  602.  
  603.  FOR_ALL_OUTPUT_UNITS(outputUnitPtr,o){
  604.    outputUnitPtr->value_a =  outputUnitPtr->value_b = outputUnitPtr->value_c = 0;
  605.    FOR_ALL_LINKS(outputUnitPtr,linkPtr){
  606.      linkPtr->value_a =  linkPtr->value_b = linkPtr->value_c = 0;
  607.    }
  608.  }
  609. }
  610.  
  611.  
  612. /*****************************************************************************
  613.   FUNCTION : cc_calculateCorrelation
  614.  
  615.   PURPOSE  : Calculates the correlation of the pool of candidate units and 
  616.              returns the high score.
  617.   NOTES    :
  618.  
  619.   UPDATE   : 5.2.93
  620. ******************************************************************************/
  621.  
  622. float cc_calculateCorrelation(int StartPattern, int EndPattern, int counter)
  623. {
  624.  int s,o,n;
  625.  float highScore=0.0,bestSpecialUnitScore,scoreBuffer;
  626.  struct Unit *SpecialUnitPtr,*OutputUnitPtr;
  627.  int start, end;
  628.  
  629.  KernelErrorCode = kr_initSubPatternOrder(StartPattern,EndPattern);
  630.  ERROR_CHECK;
  631.  start = kr_AbsPosOfFirstSubPat(StartPattern+1);
  632.  end   = kr_AbsPosOfFirstSubPat(EndPattern-1);
  633.  end  += kr_NoOfSubPatPairs(EndPattern-1) - 1;
  634.  
  635.  n = end - start + 1;
  636.  
  637.  bestSpecialUnitPtr = NULL;
  638.  bestSpecialUnitScore = 0.0;
  639.  if(cc_printOnOff) {
  640.    printf("Cycle %d ",counter);
  641.  } 
  642.  
  643.  
  644.  FOR_ALL_SPECIAL_UNITS(SpecialUnitPtr,s) {
  645.    FOR_ALL_OUTPUT_UNITS(OutputUnitPtr,o) {
  646.      scoreBuffer =  (CorBetweenSpecialActAndOutError[s][o] - 
  647.                     (OutputUnitSumError[o]/n  * SpecialUnitSumAct[s])) / SumSqError;
  648.      highScore += fabs(scoreBuffer);
  649.      CorBetweenSpecialActAndOutError[s][o] = SIGN(scoreBuffer);
  650.    }
  651.    if(highScore > bestSpecialUnitScore) {
  652.      bestSpecialUnitScore = highScore;
  653.      bestSpecialUnitPtr = SpecialUnitPtr;
  654.    }
  655.    if(cc_printOnOff) {
  656.      printf("S[%d]: %.4f ",s,highScore);
  657.    }
  658.    highScore = 0.0;
  659.  }
  660.  if(cc_printOnOff) {
  661.    printf("\n");
  662.  } 
  663.  
  664.  return(bestSpecialUnitScore);
  665. }
  666.  
  667. /*****************************************************************************
  668.   FUNCTION : cc_initInputUnitsWithPattern
  669.  
  670.   PURPOSE  : Initialize the input layer with pattern PatternNo.
  671.   NOTES    :
  672.  
  673.   UPDATE   : 5.2.93
  674. ******************************************************************************/
  675.  
  676. void cc_initInputUnitsWithPattern(int SubPatternNo)
  677. {
  678.   register struct Unit   *unit_ptr;
  679.   register Patterns  in_pat;
  680.   register int dummy;
  681.   int pat, sub;
  682.   
  683.  
  684.   kr_getSubPatternByNo(&pat,&sub,SubPatternNo);
  685.   in_pat = kr_getSubPatData(pat,sub,INPUT,NULL);
  686.  
  687.   FOR_ALL_INPUT_UNITS(unit_ptr,dummy){
  688.     if(unit_ptr->out_func == OUT_IDENTITY) {
  689.       unit_ptr->Out.output = unit_ptr->act = *in_pat++;
  690.     }
  691.     else {
  692.       unit_ptr->Out.output = (*unit_ptr->out_func) (unit_ptr->act = *in_pat++);
  693.     }
  694.   }
  695. }
  696.  
  697.  
  698.  
  699. /*****************************************************************************
  700.   FUNCTION : cc_setHiddenUnit
  701.  
  702.   PURPOSE  : Positions the hidden layer.
  703.   NOTES    :
  704.  
  705.   UPDATE   : 5.2.93
  706. ******************************************************************************/
  707.  
  708. krui_err cc_setHiddenUnit(struct Unit *hiddenUnitPtr, int maxYPosOfHiddenUnit,
  709.                           int *xPosOfLastInsertedHiddenUnit, int *yPosOfLastInsertedHiddenUnit)
  710.  
  711. {
  712.  struct Unit *outputUnitPtr,*specialUnitPtr;
  713.  int dummy;
  714.  
  715.  if(*yPosOfLastInsertedHiddenUnit<maxYPosOfHiddenUnit){
  716.    SET_UNIT_XPOS(hiddenUnitPtr,*xPosOfLastInsertedHiddenUnit);
  717.    SET_UNIT_YPOS(hiddenUnitPtr,++*yPosOfLastInsertedHiddenUnit);
  718.  }
  719.  else {
  720.    SET_UNIT_XPOS(hiddenUnitPtr,++*xPosOfLastInsertedHiddenUnit);
  721.    SET_UNIT_YPOS(hiddenUnitPtr,*yPosOfLastInsertedHiddenUnit=Y_MIN_POS);
  722.    FOR_ALL_OUTPUT_UNITS(outputUnitPtr,dummy) {
  723.      SET_UNIT_XPOS(outputUnitPtr,GET_UNIT_XPOS(outputUnitPtr)+1);
  724.    }
  725.    FOR_ALL_SPECIAL_UNITS(specialUnitPtr,dummy) {
  726.      SET_UNIT_XPOS(specialUnitPtr,GET_UNIT_XPOS(specialUnitPtr)+1);
  727.    }
  728.  }
  729.  return(KRERR_NO_ERROR);
  730. }
  731.  
  732. /*****************************************************************************
  733.   FUNCTION : cc_setPointers
  734.  
  735.   PURPOSE  : Calculates the beginning of the input, hidden, output and special
  736.              units in the topo_ptr_array. 
  737.   NOTES    :
  738.  
  739.   UPDATE   : 5.2.93
  740. ******************************************************************************/
  741.  
  742.  
  743. krui_err cc_setPointers(void)
  744. {
  745.  FirstInputUnitPtr   = (struct Unit **)(&topo_ptr_array[1]);
  746.  if(*(FirstInputUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  747.  FirstHiddenUnitPtr  = FirstInputUnitPtr  + NoOfInputUnits  + 1;
  748.  if(*(FirstHiddenUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  749.  FirstOutputUnitPtr  = FirstHiddenUnitPtr + NoOfHiddenUnits + 1;
  750.  if(*(FirstOutputUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  751.  FirstSpecialUnitPtr = FirstOutputUnitPtr + NoOfOutputUnits + 1;    
  752.  if(*(FirstSpecialUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  753.  return(KRERR_NO_ERROR);
  754. }
  755.  
  756. /*****************************************************************************
  757.   FUNCTION : cc_initSpecialUnitLinks
  758.  
  759.   PURPOSE  : Sets all the links of the special units to zero.
  760.   NOTES    :
  761.  
  762.   UPDATE   : 5.2.93
  763. ******************************************************************************/
  764.  
  765.  
  766. krui_err cc_initSpecialUnitLinks(void)
  767. {
  768.  int s;
  769.  struct Unit *SpecialUnitPtr;
  770.  struct Link *LinkPtr;
  771.  
  772.  FOR_ALL_SPECIAL_UNITS(SpecialUnitPtr,s) {
  773.    SpecialUnitPtr->bias = 0.0;
  774.    BIAS_CURRENT_SLOPE(SpecialUnitPtr) = 0.0; 
  775.    BIAS_PREVIOUS_SLOPE(SpecialUnitPtr) = 0.0; 
  776.    BIAS_LAST_WEIGHT_CHANGE(SpecialUnitPtr) = 0.0;
  777.    FOR_ALL_LINKS(SpecialUnitPtr,LinkPtr) {
  778.      LinkPtr->weight = cc_generateRandomNo(CC_MAX_VALUE);
  779.      LN_CURRENT_SLOPE(LinkPtr) = 0.0;
  780.      LN_PREVIOUS_SLOPE(LinkPtr) = 0.0;
  781.      LN_LAST_WEIGHT_CHANGE(LinkPtr) = 0.0;
  782.    }
  783.  }
  784.  return(KRERR_NO_ERROR);
  785. }
  786.  
  787. /*****************************************************************************
  788.   FUNCTION : cc_updatePosOfSpecialUnits
  789.  
  790.   PURPOSE  : Updates the position of the special units.
  791.   NOTES    :
  792.  
  793.   UPDATE   : 5.2.93
  794. ******************************************************************************/
  795.  
  796. void cc_updatePosOfSpecialUnits(void)
  797. {
  798.  int x,outputXMax=0,s;
  799.  struct Unit *unitPtr,*specialUnitPtr;
  800.  
  801.  if(cc_cascade) {
  802.    FOR_ALL_UNITS(unitPtr) {
  803.      if(IS_OUTPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  804.        x = GET_UNIT_XPOS(unitPtr);
  805.        if((x >= outputXMax) || (outputXMax==0)){
  806.          outputXMax = x;
  807.        }
  808.      }
  809.    }
  810.  
  811.    FOR_ALL_SPECIAL_UNITS(specialUnitPtr,s){
  812.      if(specialUnitPtr != NULL) { /* this can happen if there is an error before the function "cc_setPointers" */
  813.        SET_UNIT_XPOS(specialUnitPtr,outputXMax+3);
  814.      }
  815.    }
  816.    cc_cascade = 0;
  817.  }
  818. }
  819.  
  820. /*****************************************************************************
  821.   FUNCTION : cc_deleteAllSpecialUnits
  822.  
  823.   PURPOSE  : Deletes all special units.
  824.   NOTES    :
  825.  
  826.   UPDATE   : 5.2.93
  827. ******************************************************************************/
  828.  
  829. krui_err cc_deleteAllSpecialUnits(void)
  830. {
  831.  struct Unit *UnitPtr;
  832.  
  833.  if(NoOfUnits != 0) {
  834.    FOR_ALL_UNITS(UnitPtr){
  835.      if(IS_SPECIAL_UNIT(UnitPtr) && UNIT_IN_USE(UnitPtr)){
  836.        KernelErrorCode = kr_removeUnit(UnitPtr); 
  837.        ERROR_CHECK;
  838.      }
  839.    }
  840.    kr_forceUnitGC();
  841.    NetModified = 1;
  842.  }
  843.  return(KRERR_NO_ERROR);
  844. }
  845.  
  846.  
  847.  
  848. /* Begin of print functions, only needed for debugging. */
  849.  
  850. /*****************************************************************************
  851.   FUNCTION : cc_printTopoPtrArray
  852.  
  853.   PURPOSE  : Prints the topo_ptr_array.
  854.   NOTES    : Only needed for debugging.
  855.  
  856.   UPDATE   : 5.2.93
  857. ******************************************************************************/
  858.  
  859. void cc_printTopoPtrArray(void)
  860. {
  861.  int i;
  862.  printf("topo_ptr_array\n\n"); 
  863.   if( topo_ptr_array != NULL) {
  864.     for(i=0;i<NoOfUnits+5;i++) {
  865.       printf("topo_ptr_array[%d]: %d adr: %d \n",i,(int)topo_ptr_array[i],(int)&topo_ptr_array[i]);
  866.     }
  867.   }
  868. }
  869.  
  870. /*****************************************************************************
  871.   FUNCTION : cc_printUnitArray
  872.  
  873.   PURPOSE  : Prints the unit_array.
  874.   NOTES    : Only needed for debugging.
  875.  
  876.   UPDATE   : 5.2.93
  877. ******************************************************************************/
  878.  
  879. void cc_printUnitArray(void)
  880. {
  881.  struct Unit *UnitPtr;
  882.  
  883.  printf("unit_array\n\n");
  884.  
  885.  FOR_ALL_UNITS(UnitPtr) {
  886.    if(IS_INPUT_UNIT(UnitPtr)) {
  887.      printf("adr(UnitPtr): %d %s x: %d y: %d\n",(int)UnitPtr,"INPUT",
  888.             UnitPtr->unit_pos.x,UnitPtr->unit_pos.y);
  889.    }
  890.    else if(IS_HIDDEN_UNIT(UnitPtr)) {
  891.      printf("adr(UnitPtr): %d %s x: %d y: %d\n",(int)UnitPtr,"HIDDEN",
  892.             UnitPtr->unit_pos.x,UnitPtr->unit_pos.y);
  893.    }
  894.    else if(IS_OUTPUT_UNIT(UnitPtr)) {
  895.      printf("adr(UnitPtr): %d %s x: %d y: %d\n",(int)UnitPtr,"OUTPUT",
  896.             UnitPtr->unit_pos.x,UnitPtr->unit_pos.y);
  897.    }
  898.    else if(IS_SPECIAL_UNIT(UnitPtr)) {
  899.      printf("adr(UnitPtr): %d %s x: %d y: %d\n",(int)UnitPtr,"SPECIAL",
  900.             UnitPtr->unit_pos.x,UnitPtr->unit_pos.y);
  901.    }
  902.    else if(!UNIT_IN_USE(UnitPtr)) {
  903.      printf("adr(UnitPtr): %d %s\n",(int)UnitPtr,"UNIT_NOT_IN_USE");
  904.    }
  905.    else {
  906.      printf("adr(UnitPtr): %d %s\n",(int)UnitPtr,"FEHLER");
  907.    }
  908.  }
  909. }
  910.  
  911.  
  912. /*****************************************************************************
  913.   FUNCTION : cc_printUnit
  914.  
  915.   PURPOSE  : Prints information of a single Unit.
  916.   NOTES    : Only for debugging.
  917.  
  918.   UPDATE   : 5.2.93
  919. ******************************************************************************/
  920.  
  921. void cc_printUnit(struct Unit *unit_ptr)
  922. {
  923.  if(IS_INPUT_UNIT(unit_ptr)) {
  924.    printf("adr(unit_ptr): %d %s x: %d y: %d\n",(int)unit_ptr,"INPUT",
  925.    unit_ptr->unit_pos.x,unit_ptr->unit_pos.y);
  926.  }
  927.  else if(IS_HIDDEN_UNIT(unit_ptr)) {
  928.    printf("adr(unit_ptr): %d %s x: %d y: %d\n",(int)unit_ptr,"HIDDEN",
  929.    unit_ptr->unit_pos.x,unit_ptr->unit_pos.y);
  930.  }
  931.  else if(IS_OUTPUT_UNIT(unit_ptr)) {
  932.    printf("adr(unit_ptr): %d %s x: %d y: %d\n",(int)unit_ptr,"OUTPUT",
  933.    unit_ptr->unit_pos.x,unit_ptr->unit_pos.y);
  934.  }
  935.  else if(IS_SPECIAL_UNIT(unit_ptr)) {
  936.    printf("adr(unit_ptr): %d %s x: %d y: %d\n",(int)unit_ptr,"SPECIAL",
  937.    unit_ptr->unit_pos.x,unit_ptr->unit_pos.y);
  938.  }
  939.  else if(!UNIT_IN_USE(unit_ptr)) {
  940.    printf("adr(unit_ptr): %d %s\n",(int)unit_ptr,"UNIT_NOT_IN_USE");
  941.  } 
  942. }
  943.  
  944. /*****************************************************************************
  945.   FUNCTION : cc_printAllLinks
  946.  
  947.   PURPOSE  : Prints all the links of unit *unitPtr.
  948.   NOTES    : Only for debugging.
  949.  
  950.   UPDATE   : 5.2.93
  951. ******************************************************************************/
  952.  
  953. void cc_printAllLinks(struct Unit *unitPtr)
  954. {
  955.  struct Link *linkPtr;
  956.  
  957.  if(unitPtr != NULL) {
  958.    FOR_ALL_LINKS(unitPtr,linkPtr){
  959.      if(linkPtr->to != NULL){
  960.        printf("%d <-- %d %f\n",GET_UNIT_NO(unitPtr),GET_UNIT_NO(linkPtr->to),linkPtr->weight);
  961.      }
  962.      else {
  963.        printf("%d <-- ZERO \n",GET_UNIT_NO(unitPtr));
  964.      }
  965.    }
  966.  }
  967.  else {
  968.    printf("Unit has value zero\n");
  969.  }
  970.  printf("\n");
  971. }
  972.  
  973.  
  974. /* Print-Funktionen-End */
  975.  
  976.  
  977.